const groupManager = require('../utils/groupManager');

class GroupController {
    // 加入群聊
    static joinGroup(socket, groupId) {
        try {
            // 确保groupId是字符串
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;

            // 加入群聊
            groupManager.joinGroup(normalizedGroupId, socket.id);
            socket.join(normalizedGroupId);

            // 通知其他用户有新成员加入
            socket.to(normalizedGroupId).emit('group:member_joined', {
                groupId: normalizedGroupId,
                user: {
                    avatar: socket.user.avatar || null,
                    name: socket.user.name,
                    email: socket.user.email || null,
                    isVisitor: socket.user.isVisitor ? true : null
                }
            });

            // 广播所有群聊信息更新
            socket.server.emit('group:all_groups', {
                groups: groupManager.getAllGroupsInfo(socket.server)
            });

            return true;
        } catch (error) {
            return false;
        }
    }

    // 发送群聊消息
    static sendMessage(socket, groupId, content) {
        try {
            // 确保groupId是字符串
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;

            // 创建消息对象
            const message = {
                id: Date.now().toString(),
                groupId: normalizedGroupId,
                content,
                sender: {
                    avatar: socket.user.avatar || null,
                    name: socket.user.name,
                    email: socket.user.email || null,
                    isVisitor: socket.user.isVisitor ? true : null
                },
                timestamp: new Date().toISOString()
            };

            // 添加消息到群聊
            groupManager.addMessage(normalizedGroupId, message);

            // 广播消息给群聊中的所有成员
            socket.to(normalizedGroupId).emit('group:message', message);
            // 发送给发送者
            socket.emit('group:message', message);

            return true;
        } catch (error) {
            return false;
        }
    }
    // 发送群聊提示消息
    static sendHintMessage(socket, groupId, content) {
        try {
            // 确保groupId是字符串
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;

            // 创建消息对象
            const message = {
                id: Date.now().toString(),
                groupId: normalizedGroupId,
                content,
                sender: {
                    avatar: socket.user.avatar || null,
                    name: socket.user.name,
                    email: socket.user.email || null,
                    isVisitor: socket.user.isVisitor ? true : null
                },
                timestamp: new Date().toISOString()
            };


            // 广播消息给群聊中的所有成员
            socket.to(normalizedGroupId).emit('group:hint_message', message);
            // 发送给发送者
            socket.emit('group:hint_message', message);
            return true;
        } catch (error) {
            return false;
        }
    }

    // 离开群聊
    static leaveGroup(socket, groupId) {
        try {
            // 确保groupId是字符串
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;

            // 离开群聊
            if (groupManager.leaveGroup(normalizedGroupId, socket.id)) {
                groupManager.getAllPlaybackStates(socket)
            }
            socket.leave(normalizedGroupId);

            // 通知其他用户有成员离开
            socket.to(normalizedGroupId).emit('group:member_left', {
                groupId: normalizedGroupId,
                user: {
                    avatar: socket.user.avatar || null,
                    name: socket.user.name,
                    email: socket.user.email || null,
                    isVisitor: socket.user.isVisitor ? true : null
                }
            });


            // 广播所有群聊信息更新
            socket.server.emit('group:all_groups', {
                groups: groupManager.getAllGroupsInfo(socket.server)
            });

            return true;
        } catch (error) {
            return false;
        }
    }

    // 获取群聊成员信息列表
    static getGroupMembers(socket, groupId) {
        try {
            // 确保groupId是字符串
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;

            // 获取群聊成员信息列表
            const members = groupManager.getGroupMembersInfo(normalizedGroupId, socket.server);

            // 发送成员列表给请求者
            socket.emit('group:members', {
                groupId: normalizedGroupId,
                members
            });

            return true;
        } catch (error) {
            return false;
        }
    }

    // 获取所有群聊信息
    static getAllGroups(socket) {
        try {
            // 获取所有群聊信息
            const groups = groupManager.getAllGroupsInfo(socket.server);

            // 发送所有群聊信息给请求者
            socket.emit('group:all_groups', {
                groups
            });

            return true;
        } catch (error) {
            return false;
        }
    }

    // 获取群聊播放状态
    static getPlaybackState(socket, groupId) {
        try {
            const normalizedGroupId = typeof groupId === 'string' ? groupId : groupId.groupId;
            const state = groupManager.getPlaybackState(normalizedGroupId);
            if (state) {
                socket.emit('group:playback_state', {
                    groupId: normalizedGroupId,
                    state
                });
                return true;
            }
            return false;
        } catch (error) {
            console.error('获取群聊播放状态失败:', error);
            return false;
        }
    }

    // 获取所有群聊的播放状态
    static getAllPlaybackStates(socket) {
        try {
            const states = groupManager.getAllPlaybackStates();
            socket.emit('group:all_playback_states', { states });
            return true;
        } catch (error) {
            console.error('获取所有群聊播放状态失败:', error);
            return false;
        }
    }

    // 更新群聊播放状态
    static updatePlaybackState(socket, data) {
        try {
            const { groupId, state } = data;
            const success = groupManager.updatePlaybackState(groupId, state);

            if (success) {
                // 获取更新后的状态
                const updatedState = groupManager.getPlaybackState(groupId);
                // 获取所有群聊的播放状态
                const allStates = groupManager.getAllPlaybackStates();

                // 广播给群聊所有成员（不包括发送者）
                socket.to(groupId).emit('group:playback_state_updated', {
                    groupId,
                    state: updatedState
                });

                // 广播所有群聊的播放状态给所有成员
                socket.server.emit('group:all_playback_states', {
                    states: allStates
                });

                // 发送给发送者
                socket.emit('group:playback_state_updated', {
                    groupId,
                    state: updatedState
                });

                return true;
            }
            return false;
        } catch (error) {
            console.error('更新群聊播放状态失败:', error);
            return false;
        }
    }

    // 获取在线但未加入任何群聊的用户列表
    static getOnlineUsersNotInGroups(socket) {
        try {
            const users = groupManager.getOnlineUsersNotInGroups(socket.server);
            // 发送用户列表给请求者
            socket.emit('group:online_users_not_in_groups', {
                users
            });

            return true;
        } catch (error) {
            console.error('获取在线但未加入群聊的用户列表失败:', error);
            return false;
        }
    }

    // 退出所有聊天室
    static leaveAllGroups(socket) {
        try {
            // 获取所有群聊信息
            const groups = groupManager.getAllGroupsInfo(socket.server);

            // 遍历所有群聊
            groups.forEach(group => {
                const groupId = group.groupId;
                // 检查用户是否在该群聊中
                if (groupManager.isMember(groupId, socket.id)) {
                    // 离开群聊
                    groupManager.leaveGroup(groupId, socket.id);
                    socket.leave(groupId);

                    // 通知其他用户有成员离开
                    socket.to(groupId).emit('group:member_left', {
                        groupId: groupId,
                        user: {
                            avatar: socket.user.avatar || null,
                            name: socket.user.name,
                            email: socket.user.email || null,
                            isVisitor: socket.user.isVisitor ? true : null
                        }
                    });
                }
            });

            // 广播所有群聊信息更新
            socket.server.emit('group:all_groups', {
                groups: groupManager.getAllGroupsInfo(socket.server)
            });

            return true;
        } catch (error) {
            console.error('退出所有聊天室失败:', error);
            return false;
        }
    }
}

module.exports = GroupController; 